home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.2 Applications 1996 May / SGI IRIX 6.2 Applications 1996 May.iso / dist / impr_dev.idb / usr / impressario / src / drivers / laserjetPJL / pclpjl.c.z / pclpjl.c
C/C++ Source or Header  |  1996-05-06  |  25KB  |  898 lines
  1. /**************************************************************************
  2.  *
  3.  *           Copyright (c)    1992 Silicon Graphics, Inc.
  4.  *            All Rights Reserved
  5.  *
  6.  *       THIS    IS UNPUBLISHED PROPRIETARY SOURCE CODE OF SGI
  7.  *
  8.  * The copyright notice above does not evidence any actual of intended
  9.  * publication of such source code, and is an unpublished work by Silicon
  10.  * Graphics, Inc. This material contains CONFIDENTIAL INFORMATION that is
  11.  * the property of Silicon Graphics, Inc. Any use, duplication or
  12.  * disclosure not specifically authorized by Silicon Graphics is strictly
  13.  * prohibited.
  14.  *
  15.  * RESTRICTED RIGHTS LEGEND:
  16.  *
  17.  * Use, duplication or disclosure by the Government is subject to
  18.  * restrictions as set forth in subdivision (c)(1)(ii) of the Rights in
  19.  * Technical Data and Computer Software clause at DFARS 52.227-7013,
  20.  * and/or in similar or successor clauses in the FAR, DOD or NASA FAR
  21.  * Supplement. Unpublished - rights reserved under the Copyright Laws of
  22.  * the United States. Contractor is SILICON GRAPHICS, INC., 2011 N.
  23.  * Shoreline Blvd., Mountain View, CA 94039-7311
  24.  **************************************************************************
  25.  *
  26.  * File: pclpjl.c
  27.  *
  28.  * Summary:
  29.  *    PCL/PJL utility library.  Contains routines to generate common
  30.  *    PCL amd PJL commands.
  31.  *
  32.  * Description and guidelines:
  33.  *
  34.  *    Set of routines that know how to drive HP PCL printers.  Written for
  35.  *    the HP laserjet models 4Plus and newer.  
  36.  *
  37.  *    PCL functions start with 'pcl'.  PJL functions start with 'pjl'
  38.  *    PJL functions called after PCL functions (typically).
  39.  *    Not designed as a set of isolation routines -- caller needs to
  40.  *    call in correct order and should understand the internals before
  41.  *    using.  
  42.  *
  43.  *    All functions return LJ_EXIT_OK if no error; else an error code from 
  44.  *    pclpjl.h is returned;
  45.  *
  46.  *    ferror should be used by the caller if the returned error is
  47.  *    LJ_WRITE_STREAM_ERR.
  48.  *
  49.  *    Routines that do not start with 'pcl' or 'pjl' should not be 
  50.  *    used outside of this file.
  51.  *
  52.  * See Also:
  53.  *    Hp's PCL and PJL manuals
  54.  * 
  55.  **************************************************************************/
  56.     
  57. #ident "$Revision: 1.5 $"
  58.  
  59. #include <stdlib.h>
  60. #include <unistd.h>
  61. #include <stdio.h>
  62. #include <bstring.h>
  63. #include <math.h>
  64. #include "laserjetPJL.h"
  65. #include "pclpjl.h"
  66.  
  67. /* Header string for each line to send to printer */
  68.  
  69. #define HEADER_LEN 40
  70.  
  71. /* Model number in use.  Should be set by caller with escSetModel before
  72.  * calling other functions.  Allows some functions to be slightly different
  73.  * if a particular model requries it.
  74.  */
  75.  
  76. static int Model = LJ_MODEL_DEFAULT;
  77.  
  78. /* Tells us if we have set the compression mode */
  79.  
  80. static int CompressionSet = -1;
  81.  
  82. /* Once in ratser mode we set InRasterMode so we can get out if job aborted. */
  83.  
  84. static boolean InRasterMode = FALSE;
  85.  
  86. static boolean NoPJL = FALSE;
  87.  
  88. static boolean Debug = FALSE;
  89.  
  90. static int HorizResolution = DEFAULT_RESOLUTION;  
  91. static int VertResolution  = DEFAULT_RESOLUTION;  
  92.  
  93. /**************************************************************************/
  94.  
  95. int pjlsetNoPJL(boolean noPJL)
  96. {
  97.    NoPJL = noPJL;
  98.    return (LJ_EXIT_OK); 
  99.     
  100. }
  101.  
  102. /**************************************************************************/
  103.  
  104. int pjlSetModel(char *modelName) 
  105. {
  106.  
  107.    /* Call first, used by all routines if they need to do something
  108.     * device specific.  Compares modelName to known model names in the
  109.     * pclpjl.h file.
  110.     */
  111.  
  112.    int ii;
  113.  
  114.    Model = LJ_MODEL_DEFAULT;
  115.    for (ii=0; ii<LJ_NUM_MODELS; ii++) {
  116.       if (!(strcasecmp(modelName,LJ_MODEL_NAMES[ii]))) {
  117.          Model = ii; 
  118.          break;
  119.       }
  120.    }
  121.  
  122.    if (Debug) {
  123.       fprintf(stderr,"pjlSetModel: model=%s\n",modelName);
  124.       fprintf(stderr,"pjlSetModel: Model=%i\n",Model);
  125.    }
  126.  
  127.    return (LJ_EXIT_OK); 
  128. }
  129.  
  130. /**************************************************************************/
  131.  
  132. int pjlGetModel() 
  133. { 
  134.    /* Supply model to caller in case caller does something device specific */
  135.  
  136.    if (Debug) fprintf(stderr,"pjlGetModel called.  Model=%i\n",Model);
  137.  
  138.    return(Model);
  139. }
  140.  
  141. /**************************************************************************/
  142.  
  143. int pjlEnterPJLMode(FILE *out)
  144. {
  145.    /* Enter PJL mode by sending UEL */
  146.  
  147.    if (Debug) fprintf(stderr,"pjlEnterPJLMode called\n");
  148.  
  149.    if (NoPJL) return (LJ_EXIT_OK);
  150.  
  151.    if (fprintf(out,"\033%%-12345X@PJL\n")<0) return(LJ_WRITE_STREAM_ERR);
  152.  
  153.    if (fflush(out) != 0) return (LJ_WRITE_STREAM_ERR); 
  154.  
  155.    return (LJ_EXIT_OK);
  156. }
  157.  
  158. /**************************************************************************/
  159.  
  160. int pjlResetPrinter(FILE *out)
  161. {
  162.  
  163.    /* Normally called at end of job to reset all the printer 
  164.     * settings set with @PJL SET commands back to their front
  165.     * panel defaults.
  166.     */
  167.  
  168.    if (Debug) fprintf(stderr,"pjlResetPrinter called\n");
  169.  
  170.    if (NoPJL) return (LJ_EXIT_OK);
  171.  
  172.    if (fprintf(out,"@PJL RESET\r\n") < 0) return(LJ_WRITE_STREAM_ERR);
  173.  
  174.    if (fflush(out) != 0) return (LJ_WRITE_STREAM_ERR);
  175.  
  176.    return (LJ_EXIT_OK);
  177. }
  178.  
  179. /**************************************************************************/
  180.  
  181. int pjlEnterPCLMode(FILE *out)
  182. {
  183.    /* Enter PCL mode, anything sent after this should  be PCL  
  184.     * (but that is not enforced by these routines).  Normally an
  185.     * <esc>E is sent right after this.  See pclResetPrinter.
  186.     */
  187.  
  188.    if (Debug) fprintf(stderr,"pjlEnterPCLMode called\n");
  189.  
  190.    if (NoPJL) return (LJ_EXIT_OK);
  191.  
  192.    if (fprintf(out,"@PJL ENTER LANGUAGE=PCL\n") < 0) {
  193.       return(LJ_WRITE_STREAM_ERR);
  194.    }
  195.  
  196.    if (fflush(out) != 0) return (LJ_WRITE_STREAM_ERR); 
  197.  
  198.    return (LJ_EXIT_OK);
  199. }
  200.  
  201. /**************************************************************************/
  202.  
  203. int pjlSetCopies(FILE *out, int copies)
  204. {
  205.    /* Set number of copies.  Only check is that it is greater then 1 */
  206.     
  207.    if (Debug) fprintf(stderr,"pjlSetCopies called. copies=%i\n",copies);
  208.  
  209.    if (NoPJL) return (LJ_EXIT_OK);
  210.  
  211.    if (copies>1) {
  212.       if (fprintf(out,"@PJL SET COPIES=%i\n",copies) < 0) {
  213.          return(LJ_WRITE_STREAM_ERR);
  214.       }
  215.    }
  216.  
  217.    return (LJ_EXIT_OK);
  218. }
  219.  
  220. /**************************************************************************/
  221. int pjlSetPageProtect(FILE *out, boolean onoff)
  222. {
  223.  
  224.    /* You almost always want this turned off so the printer would not have 
  225.     * to load a full page before printing it.
  226.     */
  227.  
  228.    /*
  229.     * Model    Notes:
  230.     * 4V       Ignored (allow user to set on front panel) 
  231.     * 4P       Ignored (allow user to set on front panel) 
  232.     * 4PLUS    Ignored (allow user to set on front panel)
  233.     * 4SI      Ignored (allow user to set on front panel)
  234.     * 5L       Supports ON, OFF, AUTO (use OFF over AUTO)
  235.     * 5P       Supports ON, OFF, AUTO (use OFF over AUTO)
  236.     * 5SI      Ignored (allow user to set on front panel)
  237.    */
  238.    if  (Debug) fprintf(stderr,"pjlSetPageProtect called. onoff=%i\n",onoff);
  239.  
  240.    if (NoPJL) return (LJ_EXIT_OK);
  241.  
  242.    if ((Model ==  LJ_MODEL_5P) || (Model ==  LJ_MODEL_5L)) {
  243.       if (onoff) {
  244.          if (fprintf(out,"@PJL SET PAGEPROTECT=ON\n") < 0) {
  245.             return(LJ_WRITE_STREAM_ERR);
  246.          }
  247.       } else {
  248.          if (fprintf(out,"@PJL SET PAGEPROTECT=OFF\n") < 0) {
  249.              return(LJ_WRITE_STREAM_ERR);
  250.          }
  251.       }
  252.    }
  253.  
  254.    return (LJ_EXIT_OK);
  255. }
  256.  
  257. /**************************************************************************/
  258.  
  259. int pjlSetRes(FILE *out, int xres, int yres)
  260. {
  261.  
  262.    /* Note that setting resolution in PJL does not set the resolution for
  263.     * pcl raster graphics.  See pclSetRes.  
  264.     */
  265.  
  266.    if (Debug) {
  267.       fprintf(stderr,"pjlSetRes called. xres=%i, yres=%i\n",xres,yres);
  268.    }
  269.  
  270.    if (NoPJL) return (LJ_EXIT_OK);
  271.  
  272.    HorizResolution = xres;
  273.    VertResolution  = yres;
  274.  
  275.    if (fprintf(out,"@PJL SET RESOLUTION=%i\n",xres) < 0) {
  276.       return(LJ_WRITE_STREAM_ERR);
  277.    }
  278.  
  279.    return (LJ_EXIT_OK);
  280. }
  281.  
  282. /**************************************************************************/
  283.  
  284. int pjlSetPaperSize(FILE *out, int size)
  285. {
  286.    /* Supported paper size varies by device.  Check is not done 
  287.     * to insure device supports requested paper size.
  288.     */
  289.  
  290.    if (Debug) fprintf(stderr,"pjlSetPaperSize called. Size=%i\n",size);
  291.  
  292.    if (NoPJL) return (LJ_EXIT_OK);
  293.  
  294.    /* A 4P can jam if you tell it one paper size and another is loaded.
  295.     * So, don't set it in software -- user must set on front panel.  We
  296.     * still want user to set it on GUI so text2ps can create page breaks
  297.     * at correct location so it is still available to the user.
  298.     */
  299.  
  300.    if (Model == LJ_MODEL_4P) return (LJ_EXIT_OK);
  301.  
  302.    if (fprintf(out,"@PJL SET PAPER=") < 0) return(LJ_WRITE_STREAM_ERR);
  303.    
  304.    switch (size) {
  305.  
  306.        case -999:
  307.           if (Debug) fprintf(stderr,"pjlSetPaperSize size is CUSTOM\n");
  308.           if (fprintf(out,"CUSTOM\n") < 0) return(LJ_WRITE_STREAM_ERR);
  309.           break;
  310.  
  311.        case PD_SIZE_LEGAL:
  312.           if (Debug) fprintf(stderr,"pjlSetPaperSize size is LEGAL\n");
  313.           if (fprintf(out,"LEGAL\n") < 0) return(LJ_WRITE_STREAM_ERR);
  314.           break;
  315.  
  316.        case PD_SIZE_B:
  317.           if (Debug) fprintf(stderr,"pjlSetPaperSize size is LEDGER\n");
  318.           if (fprintf(out,"LEDGER\n") < 0) return(LJ_WRITE_STREAM_ERR);
  319.           break;
  320.  
  321.        case PD_SIZE_A4:
  322.           if (Debug) fprintf(stderr,"pjlSetPaperSize size is A4\n");
  323.           if (fprintf(out,"A4\n") < 0) return(LJ_WRITE_STREAM_ERR);
  324.           break;
  325.  
  326.        case PD_SIZE_A3:
  327.           if (Debug) fprintf(stderr,"pjlSetPaperSize size is A3\n");
  328.           if (fprintf(out,"A3\n") < 0) return(LJ_WRITE_STREAM_ERR);
  329.           break;
  330.  
  331.        case PD_SIZE_EXEC:
  332.           if (Debug) fprintf(stderr,"pjlSetPaperSize size is EXECUTIVE\n");
  333.           if (fprintf(out,"EXECUTIVE\n") < 0) return(LJ_WRITE_STREAM_ERR);
  334.           break;
  335.  
  336.        case PD_SIZE_LETTER:
  337.        default:
  338.           if (Debug) fprintf(stderr,"pjlSetPaperSize size is LETTER\n");
  339.           if (fprintf(out,"LETTER\n") < 0) return(LJ_WRITE_STREAM_ERR);
  340.           break;
  341.   }
  342.  
  343.    return (LJ_EXIT_OK);
  344. }
  345.  
  346. /**************************************************************************/
  347.  
  348. int pjlSetDuplex(FILE *out, int duplex)
  349. {
  350.    /* Only send this if the device supports duplexor.  We only send the PJL
  351.     * command if duplex is turned on.
  352.     */
  353.  
  354.    /*
  355.     * Model    Notes:
  356.     * 4V       Ignored
  357.     * 4P       Ignored
  358.     * 4PLUS    Supported (optional)
  359.     * 4SI      Supported (optional)
  360.     * 5L       Ignored
  361.     * 5P       Ignored
  362.     * 5SI      Supported (optional)
  363.    */
  364.  
  365.    if (Debug) fprintf(stderr,"pjlSetDuplexcalled.  duplex=%i\n",duplex);
  366.  
  367.    if (NoPJL) return (LJ_EXIT_OK);
  368.  
  369.    if (duplex == LJ_DUPLEX_OFF)  return (LJ_EXIT_OK);
  370.  
  371.    if (fprintf(out,"@PJL SET DUPLEX=ON\n") < 0) return(LJ_WRITE_STREAM_ERR);
  372.  
  373.    if (fprintf(out,"@PJL SET BINDING=") < 0) return(LJ_WRITE_STREAM_ERR);
  374.  
  375.    if (duplex == LJ_DUPLEX_SHORTSIDE) {
  376.       if (fprintf(out,"SHORTEDGE\n") < 0) return(LJ_WRITE_STREAM_ERR);
  377.    } else {
  378.       if (fprintf(out,"LONGEDGE\n") < 0) return(LJ_WRITE_STREAM_ERR);
  379.    }
  380.  
  381.    return (LJ_EXIT_OK);
  382. }
  383.  
  384. /**************************************************************************/
  385.  
  386. int pjlSetOutBin(FILE *out, int bin)
  387. {
  388.    if (Debug) fprintf(stderr,"pjlSetOutBin called. bin=%i\n",bin);
  389.    /*
  390.     * Model    Notes:
  391.     * 5SI      This is only model supported
  392.     */
  393.  
  394.     if (NoPJL) return (LJ_EXIT_OK);
  395.  
  396.     if (Model != LJ_MODEL_5SI) return (LJ_EXIT_OK);
  397.  
  398.     if (bin == LJ_OUTBIN_TOP) {
  399.        if (fprintf(out,"@PJL SET OUTBIN=UPPER\n") < 0)  {
  400.           return(LJ_WRITE_STREAM_ERR);
  401.        }
  402.     } else if (bin == LJ_OUTBIN_REAR ) {
  403.        if (fprintf(out,"@PJL SET OUTBIN=LOWER\n") < 0)  {
  404.           return(LJ_WRITE_STREAM_ERR);
  405.        }
  406.     }
  407.  
  408.     return (LJ_EXIT_OK);
  409.  
  410. }
  411.  
  412.  
  413. /**************************************************************************/
  414.  
  415. int pjlSetTray(FILE *out, int tray)
  416. {
  417.    /* Some printers set tray based on paper type; others can not. 
  418.     * This is also used to put printer into manual mode.
  419.     */
  420.  
  421.    /*
  422.     * Model    Notes:
  423.     * 4V       Only MANUAL supported, let paper size dictate tray selection
  424.     * 4P       Only MANUAL supported
  425.     * 4PLUS    Only MANUAL supported (use PCL for other trays)
  426.     * 4SI      Only MANUAL  (use PCL for other trays)
  427.     * 5L       Only MANUAL supported (no optional trays available)
  428.     * 5P       Allows MP to be set as CASSETTE, FIRST, or MANUAL
  429.     * 5SI      Only MANUAL, let paper size and media type dictate tray used
  430.     */
  431.  
  432.    if (Debug) fprintf(stderr,"pjlSetTray called. tray=%i\n",tray);
  433.  
  434.    if (NoPJL) return (LJ_EXIT_OK);
  435.  
  436.    if (tray == LJ_TRAY_MANUAL) {
  437.       if (fprintf(out,"@PJL SET MANUALFEED=ON\n") < 0) {
  438.          return(LJ_WRITE_STREAM_ERR);
  439.       }
  440.       if (Model ==  LJ_MODEL_5P) {
  441.          if (fprintf(out,"@PJL SET MPTRAY=MANUAL\n") < 0) {
  442.             return(LJ_WRITE_STREAM_ERR);
  443.          }
  444.       }
  445.       
  446.    }  else if (Model ==  LJ_MODEL_5P) {
  447.  
  448.       if (Debug) fprintf(stderr,"pjlSetTray called model is 5P\n");
  449.  
  450.       if (tray == LJ_TRAY_UPPER) {  /* Paper Cassette / Tray 2 */
  451.          if (fprintf(out,"@PJL SET MPTRAY=CASSETTE\n") < 0) {
  452.             return(LJ_WRITE_STREAM_ERR);
  453.          }
  454.       } else if (tray ==  LJ_TRAY_LOWER) { /* MP tray / Tray 1 */
  455.          if (fprintf(out,"@PJL SET MPTRAY=CASSETTE\n") < 0) {
  456.             return(LJ_WRITE_STREAM_ERR);
  457.          }
  458.       } else if (tray ==  LJ_TRAY_EITHER) {
  459.          if (fprintf(out,"@PJL SET MPTRAY=FIRST\n") < 0) {
  460.             return(LJ_WRITE_STREAM_ERR);
  461.          }
  462.       }
  463.  
  464.    } 
  465.  
  466.    return (LJ_EXIT_OK);
  467. }
  468.  
  469. /**************************************************************************/
  470.  
  471. int pjlSetDarkness(FILE *out, int darkness)
  472. {
  473.    int density=3;
  474.  
  475.    /* Valid density is 1 to 5; we support normal, dark and light.
  476.     * an Economode setting is also supported.
  477.     */
  478.  
  479.    /*
  480.     * Model    Notes:
  481.     * 4V       Only ECONOMODE set; (set density on front panel)
  482.     * 4P       ECONOMODE and DENSITY supported
  483.     * 4PLUS    Only ECONOMODE set; (set density on front panel)
  484.     * 4SI      Not supported
  485.     * 5L       ECONOMODE and DENSITY supported 
  486.     * 5P       ECONOMODE and DENSITY supported
  487.     * 5SI      Only ECONOMODE set; (set density on front panel)
  488.    */
  489.  
  490.    if (Debug) fprintf(stderr,"pjlSetDarkness called darkness=%i\n",darkness);
  491.  
  492.    if (NoPJL)  return (LJ_EXIT_OK);
  493.  
  494.    if (Model == LJ_MODEL_4SI) return (LJ_EXIT_OK);
  495.  
  496.    if (darkness == LJ_DARKNESS_ECONO) {
  497.  
  498.       if (fprintf(out,"@PJL SET ECONOMODE=ON\n") < 0) {
  499.          return(LJ_WRITE_STREAM_ERR);
  500.       }
  501.       density = 3;
  502.  
  503.    } else if (darkness == LJ_DARKNESS_LIGHT) {
  504.       density = 1;
  505.    } else if (darkness == LJ_DARKNESS_DARK) {
  506.       density = 5;
  507.    } else if (darkness == LJ_DARKNESS_NORMAL) {
  508.       density = 3;
  509.    }
  510.  
  511.    if ((Model ==  LJ_MODEL_5P) || (Model ==  LJ_MODEL_4P)) {
  512.       if (Debug) fprintf(stderr,"pjlSetDarkness default density=%i\n",density);
  513.       if (fprintf(out,"@PJL DEFAULT DENSITY=%i\n",density) < 0) {
  514.          return(LJ_WRITE_STREAM_ERR);
  515.       }
  516.    } else if (Model ==  LJ_MODEL_5L) {
  517.       if (Debug) fprintf(stderr,"pjlSetDarkness set density=%i\n",density);
  518.       if (fprintf(out,"@PJL SET DENSITY=%i\n",density) < 0) {
  519.          return(LJ_WRITE_STREAM_ERR);
  520.       }
  521.    }
  522.    
  523.    return (LJ_EXIT_OK);
  524. }
  525.  
  526. /**************************************************************************/
  527.  
  528. void pjlSetDebug(boolean onoff) 
  529. {
  530.  
  531.     /* Turn on debug nessages in the PJL and PCL functions in this file */
  532.  
  533.     Debug = onoff;
  534. } 
  535.  
  536. /**************************************************************************/
  537.  
  538. int pclSetRes(FILE *out, int xres, int yres)
  539. {
  540.  
  541.    /* Set PCL raster graphics resolution.  Settings from PJL are ignored
  542.     * so make sure you also set resolution in pcl.  yres is ignored.
  543.     */
  544.  
  545.    if (Debug) {
  546.       fprintf(stderr,"pclSetRes called. xres=%i, yres=%i\n",xres,yres);
  547.    }
  548.  
  549.    if (fprintf(out, "\033*t%dR", xres)  < 0) return(LJ_WRITE_STREAM_ERR);
  550.  
  551.    return (LJ_EXIT_OK);
  552. }
  553.  
  554. /**************************************************************************/
  555.  
  556. int pclSetLineWrap(FILE *out)
  557. {
  558.    /* Enable the end of line wrap in pcl */
  559.  
  560.    if (Debug) fprintf(stderr,"pclSetLineWrap  called\n");
  561.  
  562.    if (fprintf(out,"\033&s0C") < 0) return(LJ_WRITE_STREAM_ERR);
  563.  
  564.    return (LJ_EXIT_OK);
  565. }
  566.  
  567. /**************************************************************************/
  568.  
  569. int pclSetCrLf(FILE *out)
  570. {
  571.    /* Set CR/LF model to CR=CR; LF=CR-LF; FF=CR-FF*/
  572.  
  573.    if (Debug) fprintf(stderr,"pclSetCrLf called\n");
  574.  
  575.    if (fprintf(out,"\033&k2G") < 0) return(LJ_WRITE_STREAM_ERR);
  576.  
  577.    return (LJ_EXIT_OK);
  578. }
  579.  
  580. /**************************************************************************/
  581.  
  582. int pclFormFeed(FILE *out)
  583. {
  584.    /* Send a form feed */
  585.  
  586.    if (Debug) fprintf(stderr,"pclFormFeed called\n");
  587.  
  588.    if (fprintf(out,"\014") < 0) return(LJ_WRITE_STREAM_ERR);
  589.  
  590.    if (fflush(out) != 0) return (LJ_WRITE_STREAM_ERR);
  591.  
  592.    return (LJ_EXIT_OK);
  593. }
  594.  
  595. /**************************************************************************/
  596.  
  597. int pclResetPrinter(FILE *out)
  598. {
  599.    /* Send a PCL reset */
  600.  
  601.    if (Debug) fprintf(stderr,"pclResetPrinter called\n");
  602.  
  603.    if (fprintf(out,"\033E") < 0) return(LJ_WRITE_STREAM_ERR);
  604.  
  605.    return (LJ_EXIT_OK);
  606. }
  607.  
  608.  
  609. /**************************************************************************/
  610.  
  611. int pclSetTray(FILE *out, int tray)
  612. {
  613.  
  614.    /*
  615.     * Model    Notes:
  616.     * 4V       MANUAL and 2 trays (1 optional) supported
  617.     * 4PLUS    MANUAL and 2 trays (1 optional) supported 
  618.     * 4SI      2 Trays (standard with printer) supported
  619.     * 4P       Only MANUAL supported (no optional trays available)
  620.     * 5L       Only MANUAL supported (no optional trays available)
  621.     * 5P       Allows selection between MP tray and paper drawer
  622.     * 5SI      Not supported (paper size and type selects tray on 5SI) 
  623.    */
  624.  
  625.    if (Debug) fprintf(stderr,"pclSetTray called. tray=%i\n",tray);
  626.  
  627.    if (tray == LJ_TRAY_MANUAL) {
  628.  
  629.       if (fprintf(out,"\033&l2H") < 0) {
  630.          return(LJ_WRITE_STREAM_ERR);
  631.       }
  632.  
  633.    } else if ((Model ==  LJ_MODEL_5P) || (Model ==  LJ_MODEL_4SI) ||
  634.               (Model ==  LJ_MODEL_5SI))  {
  635.  
  636.       if (Debug) fprintf(stderr,"pclSetTray called model is 5P/4SI/4V\n");
  637.  
  638.       if (tray == LJ_TRAY_UPPER) {  /* Paper Cassette / upper / Tray 2 */
  639.          if (fprintf(out,"\033&l1H") < 0) {
  640.             return(LJ_WRITE_STREAM_ERR);
  641.          }
  642.       } else if (tray ==  LJ_TRAY_LOWER) { /* MP tray / lower/ Tray 1 */
  643.          if (fprintf(out,"\033&l4H") < 0) {
  644.             return(LJ_WRITE_STREAM_ERR);
  645.          }
  646.       }
  647.   
  648.    }  else if ((Model == LJ_MODEL_4PLUS) || (Model == LJ_MODEL_4V))  {   
  649.  
  650.       if (tray == LJ_TRAY_UPPER) {  
  651.          if (fprintf(out,"\033&l1H") < 0) {
  652.             return(LJ_WRITE_STREAM_ERR);
  653.          }
  654.       } else if (tray ==  LJ_TRAY_LOWER) { 
  655.          if (fprintf(out,"\033&l5H") < 0) {
  656.             return(LJ_WRITE_STREAM_ERR);
  657.          }
  658.       }
  659.  
  660.    }
  661.  
  662.    return (LJ_EXIT_OK);
  663. }
  664.  
  665. /**************************************************************************/
  666.  
  667. int pclPrepForGraphics(FILE *out)
  668. {
  669.    /* Get ready for graphics mode. Calls several pcl functions.
  670.     * Specific to the laserjet driver dor Impressario in that some
  671.     * values are hard-coded.
  672.     */
  673.  
  674.    if (Debug) fprintf(stderr,"pclPrepForGraphics called\n");
  675.  
  676.    /* Enter new page so mark compression used as unknown for pclSendRow */
  677.  
  678.    CompressionSet = -1;
  679.  
  680.    /* Set portrait mode on & zero top margin */
  681.  
  682.    if (fprintf(out, "\033&l0ol0E") < 0) return(LJ_WRITE_STREAM_ERR);
  683.  
  684.    /* Set zero left margin */
  685.  
  686.    if (fprintf(out, "\033&l0L") < 0) return(LJ_WRITE_STREAM_ERR);
  687.  
  688.    /* Move graphics cursor to 0,50 */
  689.  
  690.    if (fprintf(out, "\033*p0x50Y") < 0) return(LJ_WRITE_STREAM_ERR);
  691.  
  692.    /* Start raster graphics mode. */
  693.  
  694.    if (fprintf(out, "\033*r1A") < 0) return(LJ_WRITE_STREAM_ERR);
  695.    InRasterMode = TRUE;
  696.  
  697.    if (fflush(out) != 0) return (LJ_WRITE_STREAM_ERR);
  698.  
  699.    return (LJ_EXIT_OK);
  700. }
  701.  
  702. /**************************************************************************/
  703.  
  704. int pclPrepForNextPage(FILE *out)
  705. {
  706.    if (Debug) fprintf(stderr,"pclPrepForNextPage called\n");
  707.  
  708.    /* Get ready for next page */
  709.  
  710.    /* End raster graphics */
  711.  
  712.    if (InRasterMode) {
  713.      if (fprintf(out, "\033*rC") < 0) return(LJ_WRITE_STREAM_ERR);
  714.      InRasterMode = FALSE;
  715.    }
  716.  
  717.    if (pclFormFeed(out) != LJ_EXIT_OK) return(LJ_WRITE_STREAM_ERR);
  718.  
  719.    return (LJ_EXIT_OK);
  720. }
  721.  
  722. /**************************************************************************/
  723.  
  724. int pclFlushPages(FILE *out)
  725. {
  726.    if (Debug) fprintf(stderr,"pclFlushPages called\n");
  727.  
  728.    if (fprintf(out, "\033&r1F") < 0) return(LJ_WRITE_STREAM_ERR);
  729.  
  730.    if (fflush(out) != 0) return (LJ_WRITE_STREAM_ERR);
  731.  
  732.    return (LJ_EXIT_OK);
  733. }
  734.  
  735. /**************************************************************************/
  736.  
  737. int pclCleanupPrinter(FILE *out)
  738. {
  739.    if (Debug) fprintf(stderr,"pclCleanupPrinter called\n");
  740.  
  741.    /* End raster graphics */
  742.  
  743.    if (InRasterMode) {
  744.       if (fprintf(out, "\033*rC") < 0) return(LJ_WRITE_STREAM_ERR);
  745.       InRasterMode = FALSE;
  746.    }
  747.  
  748.    /* Send Job Separation command. */
  749.  
  750.    if (fprintf(out, "\033&l1T") < 0) return(LJ_WRITE_STREAM_ERR);
  751.  
  752.    if (pclResetPrinter(out) != LJ_EXIT_OK) return(LJ_WRITE_STREAM_ERR);
  753.  
  754.    if (fprintf(out,"\033%%-12345X") < 0) return(LJ_WRITE_STREAM_ERR);
  755.  
  756.    if (pjlEnterPJLMode(out) != LJ_EXIT_OK) return(LJ_WRITE_STREAM_ERR);
  757.  
  758.    if (pjlResetPrinter(out) != LJ_EXIT_OK) return(LJ_WRITE_STREAM_ERR);
  759.  
  760.    if (fflush(out) != 0) return (LJ_WRITE_STREAM_ERR);
  761.  
  762.     return (LJ_EXIT_OK);
  763. }
  764.  
  765.  
  766. /**************************************************************************/
  767.  
  768. int packbits(unsigned char *ibits, unsigned char *pbits, int nbytes)
  769. {
  770.     unsigned char *sptr;
  771.     unsigned char *ibitsend;
  772.     unsigned char *optr = pbits;
  773.     int todo, cc, count;
  774.  
  775.     ibitsend = ibits+nbytes;
  776.     while(ibits<ibitsend) {
  777.         sptr = ibits;
  778.         ibits += 2;
  779.         while((ibits<ibitsend)&&((ibits[-2]!=ibits[-1])||(ibits[-1]!=ibits[0])))            ibits++;
  780.         if(ibits != ibitsend) {
  781.             ibits -= 2;
  782.         }
  783.         count = ibits-sptr;
  784.         while(count) {
  785.             todo = count>128 ? 128:count;
  786.             count -= todo;
  787.             *optr++ = todo-1;
  788.             while(todo--)
  789.                 *optr++ = *sptr++;
  790.         }
  791.         if(ibits == ibitsend)
  792.             break;
  793.         sptr = ibits;
  794.         cc = *ibits++;
  795.         while( (ibits<ibitsend) && (*ibits == cc) )
  796.             ibits++;
  797.         count = ibits-sptr;
  798.         while(count) {
  799.             todo = count>128 ? 128:count;
  800.             count -= todo;
  801.             *optr++ = 257-todo;
  802.             *optr++ = cc;
  803.         }
  804.     }
  805.     return optr-pbits;
  806. }
  807.  
  808. /**************************************************************************/
  809.  
  810. int set_compression_2(FILE *out)
  811. {
  812.     if (fprintf(out,"\033*b2m")  < 0) return(LJ_WRITE_STREAM_ERR);
  813.     CompressionSet=2;
  814.     return (LJ_EXIT_OK);
  815. }
  816.  
  817. /**************************************************************************/
  818.  
  819. int set_compression_off(FILE *out)
  820. {
  821.     if (fprintf(out,"\033*b0m")  < 0) return(LJ_WRITE_STREAM_ERR);
  822.     CompressionSet=0;
  823.     return (LJ_EXIT_OK);
  824. }
  825.  
  826. /**************************************************************************/
  827.  
  828. int pclSendRow(FILE *out, unsigned char *row, unsigned long numBytes)
  829. {
  830.  
  831.     /* Send a row of raster data -- compresses and then sends */
  832.  
  833.     int bufSizeNeeded;
  834.     int bytesToWrite;
  835.     int compressLength;
  836.     int count;
  837.     int lineCount;
  838.     unsigned char *writeBuf;
  839.     unsigned char HeaderCmd[HEADER_LEN];
  840.     static int Buflength = 0;
  841.     static unsigned char *compressedRow = NULL;  
  842.  
  843.     int packbits(unsigned char *ibits, unsigned char *pbits, int nbytes);
  844.     int set_compression_off(FILE *out);
  845.     int set_compression_2(FILE *out);
  846.  
  847.     bufSizeNeeded = numBytes;
  848.  
  849.     if (Buflength < bufSizeNeeded) {  /* alloc, re-alloc as needed */
  850.        if (Buflength == 0)  {   /* first time through */
  851.           Buflength = bufSizeNeeded; 
  852.           compressedRow=(unsigned char *)malloc(Buflength*2);
  853.        } else {
  854.           Buflength = bufSizeNeeded; 
  855.           compressedRow=(unsigned char *)realloc(compressedRow,Buflength*2);
  856.        }
  857.     }
  858.  
  859.     if (!compressedRow) {
  860.        fprintf(stderr,"malloc failed while allocating bytes of memory");
  861.        exit(1);
  862.     }
  863.  
  864.     bytesToWrite = Buflength;
  865.     writeBuf = row; 
  866.  
  867.     compressLength = packbits(row, compressedRow, Buflength);
  868.     if (compressLength < Buflength) {
  869.         bytesToWrite = compressLength;
  870.         writeBuf = compressedRow;
  871.         if (CompressionSet != 2) {
  872.            if (set_compression_2(out) != LJ_EXIT_OK) {
  873.                return (LJ_WRITE_STREAM_ERR);
  874.            }
  875.         }
  876.         lineCount = sprintf(HeaderCmd,"\033*b%uW",bytesToWrite);
  877.     } else {
  878.         if (CompressionSet != 0) {
  879.            if (set_compression_off(out) != LJ_EXIT_OK) {
  880.                return (LJ_WRITE_STREAM_ERR);
  881.            }
  882.         }
  883.     }
  884.  
  885.     lineCount = sprintf(HeaderCmd,"\033*b%uW",bytesToWrite);
  886.     count = fwrite(HeaderCmd, 1, lineCount, out);
  887.     if (count != lineCount) return (LJ_WRITE_STREAM_ERR);
  888.  
  889.     count = fwrite(writeBuf, 1, bytesToWrite, out);
  890.     if (count != bytesToWrite) return (LJ_WRITE_STREAM_ERR);
  891.  
  892.     fflush(out);
  893.  
  894.     return (LJ_EXIT_OK);
  895. }
  896.  
  897. /**************************************************************************/
  898.